// 全局变量
let propertyData = [] // 权属数据
let fusionResults = [] // 融合结果
let fusionEngine = null // 融合引擎
let excelProcessor = null // Excel处理器
let spatialData = [] // 空间数据
let controlPanelVisible = true // 控制面板显示状态

// 这个是 Cesium 的 授权token
Cesium.Ion.defaultAccessToken =
  'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJqdGkiOiIxZDEwMzg3NS03MWY1LTRkZGYtOTRlMS03NWQxYjU2YmU3YjUiLCJpZCI6MjE2OTQyLCJpYXQiOjE3NTU5NTY5NzJ9.PFKivKTnwWWkewl97bd1LKXHJawwaAva6wlZmPEorhg'

// 获取 cesium 放置的位置
const viewer = new Cesium.Viewer('cesiumContainer',{
  // terrainProvider: Cesium.createWorldTerrain(), // 添加地形
  // baseLayerPicker: true, // 显示图层选择器
  })



// 创建一个Cesium3DTileset实例并添加到场景中
var tileset = viewer.scene.primitives.add(
  new Cesium.Cesium3DTileset({
    //  使用相对路径就可以
    url: './bimdata/22/tileset.json',
  }),
)

// 监听加载完成事件
tileset.readyPromise
  .then(function () {
    // 当tileset准备就绪后，你可以调整相机位置等
    viewer.zoomTo(tileset)

    // 初始化融合系统
    initializeFusionSystem()
  })
  .otherwise(function (error) {
    // 处理加载错误
    console.error('An error occurred: ', error)
  })

// 初始化融合系统
function initializeFusionSystem() {
  try {
    // 初始化Excel处理器和融合引擎
    excelProcessor = new ExcelDataProcessor()
    fusionEngine = new RealEstateDataFusion()

    // 确保commonJsData已加载
    if (typeof window.commonJsData === 'undefined') {
      throw new Error('空间数据文件(common.js)未正确加载')
    }

    // 处理空间数据
    spatialData = excelProcessor.processSpatialData(window.commonJsData)
    console.log(spatialData,'<<<<<')

    console.log('融合系统初始化完成，空间数据:', spatialData.length, '条')
    updateStatus(
      'uploadStatus',
      `✅ 系统初始化完成，已加载${spatialData.length}条空间数据`,
      'success',
    )
  } catch (error) {
    console.error('融合系统初始化失败:', error)
    updateStatus(
      'uploadStatus',
      `❌ 系统初始化失败: ${error.message}`,
      'error',
    )
  }
}

function addBoxClassificationPrimitive() {
  allList.forEach((item) => fn(item))
}

function fn(item) {
  let length = 18,
    width = 10.5,
    height = 3,
    baseHeight = 1 //楼的长宽高和基地高

  var cartesian3 = Cesium.Cartesian3.fromDegrees(...item.position)
  // 用Cesium库中的Cartesian3方法将地理坐标（经度、纬度）转换为三维笛卡尔坐标

  for (var i = 0; i < item.detail.length; i++) {
    //用于将一个东-北-上（ENU）坐标系中的点转换到一个固定的笛卡尔坐标系中。这个方法通常用于将飞机或无人机的位置从它们的局部坐标系转换到全局坐标系。
    var modelMatrix =
      Cesium.Transforms.eastNorthUpToFixedFrame(cartesian3)
    //根据给定的偏航（Heading）、俯仰（Pitch）和翻滚（Roll）角度创建一个 3x3 旋转矩阵。
    hprRotation = Cesium.Matrix3.fromHeadingPitchRoll(
      new Cesium.HeadingPitchRoll(Cesium.Math.toRadians(-6), 0.0, 0.0),
    )
    //用于根据旋转和平移向量创建一个 4x4 变换矩阵。这个矩阵可以表示一个物体在空间中的旋转和平移，常用于设置场景中实体的位置和方向。
    hpr = Cesium.Matrix4.fromRotationTranslation(
      hprRotation,
      new Cesium.Cartesian3(0.0, 0.0, baseHeight + 3 * i), //楼层高度上的偏移
    )

    //旋转矩阵Matrix3
    let mz = Cesium.Matrix3.fromRotationZ(Cesium.Math.toRadians(85))
    let rotationZ = Cesium.Matrix4.fromRotationTranslation(mz)
    //Cesium.Matrix4.multiply(modelMatrix, rotationX, modelMatrix)
    //Cesium.Matrix4.multiply(modelMatrix, rotationY, modelMatrix)
    Cesium.Matrix4.multiply(modelMatrix, rotationZ, modelMatrix)

    Cesium.Matrix4.multiply(modelMatrix, hpr, modelMatrix)
    const build_no = item.detail[0].attribute.build_no

    const instance = new Cesium.GeometryInstance({
      geometry: Cesium.BoxGeometry.fromDimensions({
        vertexFormat: Cesium.PerInstanceColorAppearance.VERTEX_FORMAT,
        dimensions: new Cesium.Cartesian3(length, width, height),
      }),
      modelMatrix: modelMatrix,
      attributes: {
        color: Cesium.ColorGeometryInstanceAttribute.fromColor(
          getColor(i),
        ),
        show: new Cesium.ShowGeometryInstanceAttribute(true), //设置初始化后是否显示
      },
      id: build_no + '-' + item.unitNum + '-' + `${i + 1}`+`=D${build_no.slice(0, 1)}/${item.unitNum}0${i + 1}`,  
    })
    buildingHighlight1 = viewer.scene.primitives.add(
      new Cesium.ClassificationPrimitive({
        geometryInstances: instance,
        classificationType: Cesium.ClassificationType.CESIUM_3D_TILE, //只绘制在3dtiles上
      }),
    )
  }
}

var handler = new Cesium.ScreenSpaceEventHandler(viewer.canvas)
handler.setInputAction(function (movement) {
  getCartesianCoordinate(movement.position)
  var pickedObject = viewer.scene.pick(movement.position)
  if (Cesium.defined(pickedObject) && pickedObject.primitive) {
    if (pickedObject.id) {
      getAttribute(pickedObject.id)
      console.log('你点击了第' + pickedObject.id + '户')
    }
  }
}, Cesium.ScreenSpaceEventType.LEFT_CLICK)

const getCartesianCoordinate = (pos) => {
  //获取点击位置的经纬度
  console.log('pos: ', pos)
  let cartesianCoordinate = viewer.scene.pickPosition(pos)
  if (!cartesianCoordinate) {
    return null
  }
  let cartographic = //将笛卡尔坐标转换为地理坐标
    Cesium.Cartographic.fromCartesian(cartesianCoordinate)
  let longitude = Cesium.Math.toDegrees(cartographic.longitude)
  let latitude = Cesium.Math.toDegrees(cartographic.latitude)
  let height = cartographic.height
  let position = {
    longitude: Number(longitude.toFixed(6)),
    latitude: Number(latitude.toFixed(6)),
    altitude: Number(height.toFixed(2)),
  }
  console.log('坐标: ', position)
  return position
}

function getColor(inx) {
  // new Cesium.Color(1.0, 0.0, 0.0, 0.5)//设置高亮颜色
  // 使用红、绿、蓝和透明度值创建颜色对象（范围从 0 到 1）
  if (inx % 5 === 0) {
    return new Cesium.Color(1.0, 0.0, 0.0, 0.5)
  }

  if (inx % 5 === 1) {
    return new Cesium.Color(0.3, 1.0, 0.4, 0.5)
  }
  if (inx % 5 === 2) {
    return new Cesium.Color(0.0, 0.5, 1.0, 0.5)
  }
  if (inx % 5 === 3) {
    return new Cesium.Color(0.5, 0.0, 1.0, 0.5)
  }
  if (inx % 5 === 4) {
    return new Cesium.Color(0.5, 0.5, 1.0, 0.5)
  }
  return new Cesium.Color(0.0, 1.0, 1.0, 0.5)
}

function getAttribute(id) {
  console.log('id: ', id);
  const newID = id.split('=')[1]
  const [build_no, unitNum, layers] = id.split('=')[0].split('-')
  const unitItem = allList
    .filter((item) => item.detail[0].attribute.build_no === build_no)
    .find(
      (item) => item.unitNum === Number(unitNum), //获取单元信息
    )
  const layersItem = unitItem.detail.find(
    (item) => item.layers === Number(layers), //获取楼层信息
  )
  console.log('layersItem: ', layersItem.attribute)

  // 查找融合结果
  const fusionResult = findFusionResult(id,newID)

  show(layersItem.attribute, id, fusionResult)
}

// 查找融合结果 - 改进版，支持多种房屋ID格式匹配
function findFusionResult(roomId,newID) {
  if (fusionResults.length === 0) {
    console.log('融合结果为空，无法匹配')
    return null
  }

  console.log('正在查找融合结果，房屋ID:', roomId)
  console.log('可用的融合结果数量:', fusionResults.length)

  // 解析点击的房屋ID (格式: "1号楼-2-34")
  const [buildingName, unitNum, floorNum] = roomId.split('-')

  // 尝试多种匹配策略
  let foundResult = null
  // 策略1: 精确匹配
  foundResult = fusionResults.find((result) => {
    return (
      result.spatialData.fullRoomId === roomId ||
      result.spatialData.roomId === roomId ||
      result.spatialData.originalId === roomId
    )
  })

  console.log('foundResult:1 ', foundResult);
  if (foundResult) {
   console.log('✅ 精确匹配成功:', foundResult)
    return foundResult
  }

  // 策略2: 建筑+楼层匹配
  foundResult = fusionResults.find((result) => {
    const spatialData = result.spatialData
    

    // 匹配建筑号 (1号楼 → D1, 2号楼 → D2 等)
    const buildingMatch = matchBuildingNumber(
      buildingName,
      spatialData.buildingId,
    )

    // 匹配房间号 (单元+楼层 → 房间号)
    const roomMatch = matchRoomNumber(
      unitNum,
      floorNum,
      spatialData.roomNumber,
    )

    return buildingMatch && roomMatch
  })
  console.log('foundResult:2 ', foundResult);

  if (foundResult) {
   console.log('✅ 建筑+房间匹配成功:', foundResult)
    return foundResult
  }
  debugger

  // 策略3: 模糊匹配
  foundResult = fusionResults.find((result) => { 
    return  result.spatialData.roomId.includes(newID.replace('/','-'))  
  })
  // foundResult = fusionResults.find((result) => {
  //   const spatialData = result.spatialData
  //   const buildingMatch = matchBuildingNumber(
  //     buildingName,
  //     spatialData.buildingId,
  //   )
  //   return buildingMatch
  // })
  console.log('foundResult:3 ', foundResult);

  if (foundResult) {
   console.log('✅ 模糊匹配成功:', foundResult)
    return foundResult
  }

  console.log('❌ 未找到匹配的融合结果')

  // 调试信息：显示前5个融合结果的格式
  console.log('融合结果示例:')
  fusionResults.slice(0, 5).forEach((result, index) => {
    console.log(
      `  ${index + 1}. ${result.spatialData.originalId} (建筑: ${
        result.spatialData.buildingId
      }, 房间: ${result.spatialData.roomNumber})`,
    )
  })

  return null
}

// 匹配建筑号的辅助函数
function matchBuildingNumber(allListBuilding, commonJsBuilding) {
  if (!allListBuilding || !commonJsBuilding) return false

  // 标准化建筑号
  const normalizeBuilding = (building) => {
    return building
      .toString()
      .replace(/号楼|楼|号/g, '') // 移除"号楼"等后缀
      .replace(/[^\w]/g, '') // 移除特殊字符
      .toUpperCase()
  }

  const normalized1 = normalizeBuilding(allListBuilding)
  const normalized2 = normalizeBuilding(commonJsBuilding)

  // 检查数字匹配 (1号楼 → D1)
  if (normalized1.match(/^\d+$/)) {
    const num = normalized1
    return normalized2.includes(num) || normalized2 === `D${num}`
  }

  return normalized1 === normalized2
}

// 匹配房间号的辅助函数
function matchRoomNumber(unitNum, floorNum, commonJsRoom) {
  if (!unitNum || !floorNum || !commonJsRoom) return false

  // 生成可能的房间号格式
  const possibleRooms = [
    `${floorNum}0${unitNum}`, // 标准格式: 楼层+0+单元 (如: 201, 302)
    `${floorNum}${unitNum}`, // 简化格式: 楼层+单元 (如: 21, 32)
    `${unitNum}0${floorNum}`, // 反向格式: 单元+0+楼层
    `${unitNum}${floorNum}`, // 反向简化格式
  ]

  const normalizedCommonJs = commonJsRoom.toString().replace(/[^\d]/g, '')

  return possibleRooms.some((room) => room === normalizedCommonJs)
}

// 增强版的详情显示函数
function show(attribute, id, fusionResult) {
  let content = `
              <div class="enhanced-detail">
                  <h3 style="color: #4fc3f7; margin: 0 0 15px 0; text-align: center; border-bottom: 2px solid #4fc3f7; padding-bottom: 8px;">
                      🏠 房屋详细信息
                  </h3>
          `

  // 基础空间信息
  content += `
              <div style="background: #f5f5f5; padding: 12px; border-radius: 8px; margin-bottom: 15px;">
                  <h4 style="color: #333; margin: 0 0 10px 0;">📍 空间信息</h4>
                  <dl><dt>门牌号:</dt><dd>${id}</dd></dl>
                  <dl><dt>幢数:</dt><dd>${attribute.build_no}</dd></dl>
                  <dl><dt>单元:</dt><dd>${attribute.unit}</dd></dl>
                  <dl><dt>状态:</dt><dd>${attribute.condition}</dd></dl>
                  <dl><dt>面积:</dt><dd>${attribute.area}</dd></dl>
              </div>
          `

  // 融合信息
  if (fusionResult) {
    const confidence = (fusionResult.confidence * 100).toFixed(1)
    const propertyInfo = fusionResult.propertyData

    content += `
                  <div style="background: #e8f5e8; padding: 12px; border-radius: 8px; margin-bottom: 15px; border-left: 4px solid #4caf50;">
                      <h4 style="color: #2e7d32; margin: 0 0 10px 0;">
                          👥 权属信息 
                          <span class="fusion-badge fusion-success">已融合</span>
                      </h4>
                      <dl><dt>业主姓名:</dt><dd>${
                        propertyInfo.ownerInfo.name || '未知'
                      }</dd></dl>
                      <dl><dt>身份证号:</dt><dd>${
                        propertyInfo.ownerInfo.idCard || '未提供'
                      }</dd></dl>
                      <dl><dt>联系电话:</dt><dd>${
                        propertyInfo.ownerInfo.phone || '未提供'
                      }</dd></dl>
                      <dl><dt>产权面积:</dt><dd>${
                        propertyInfo.propertyInfo.area
                          ? propertyInfo.propertyInfo.area.toFixed(2) +
                            '㎡'
                          : '未知'
                      }</dd></dl>
                      <dl><dt>房屋性质:</dt><dd>${
                        propertyInfo.propertyInfo.condition || '未知'
                      }</dd></dl>
                      <dl>
                          <dt>匹配置信度:</dt>
                          <dd>
                              ${confidence}%
                              <div class="confidence-bar">
                                  <div class="confidence-fill" style="width: ${confidence}%"></div>
                              </div>
                          </dd>
                      </dl>
                  </div>
              `

    // 匹配详细信息
    content += `
                  <div style="background: #f3f8ff; padding: 12px; border-radius: 8px; border-left: 4px solid #2196f3;">
                      <h4 style="color: #1976d2; margin: 0 0 10px 0;">🔍 匹配分析</h4>
                      <dl><dt>空间相似度:</dt><dd>${(
                        fusionResult.fusionQuality.spatialSimilarity * 100
                      ).toFixed(1)}%</dd></dl>
                      <dl><dt>语义相似度:</dt><dd>${(
                        fusionResult.fusionQuality.semanticSimilarity *
                        100
                      ).toFixed(1)}%</dd></dl>
                      <dl><dt>属性相似度:</dt><dd>${(
                        fusionResult.fusionQuality.attributeSimilarity *
                        100
                      ).toFixed(1)}%</dd></dl>
                      <dl><dt>匹配策略:</dt><dd>${
                        fusionResult.matchStrategy || '多维度相似度匹配'
                      }</dd></dl>
                  </div>
              `
  } else {
    content += `
                  <div style="background: #fff3e0; padding: 12px; border-radius: 8px; border-left: 4px solid #ff9800;">
                      <h4 style="color: #f57c00; margin: 0 0 10px 0;">
                          ❓ 权属信息 
                          <span class="fusion-badge fusion-pending">待融合</span>
                      </h4>
                      <p style="color: #666; margin: 0;">暂无对应的权属数据，请先上传Excel文件并执行数据融合。</p>
                  </div>
              `
  }

  content += '</div>'

  layer.open({
    area: ['600px', 'auto'],
    maxHeight: '80%',
    title: '房屋详细信息',
    skin: 'detail-class',
    content: content,
  })
}

// Excel文件上传处理
async function handleExcelUpload(event) {
  const file = event.target.files[0]
  if (!file) return

  updateStatus('uploadStatus', '🔄 正在处理Excel文件...', '')

  try {
    propertyData = await excelProcessor.processExcelFile(file)
    updateStatus(
      'uploadStatus',
      `✅ 成功加载${propertyData.length}条权属数据`,
      'success',
    )

    // 启用融合按钮
    document.getElementById('fusionBtn').disabled = false

    console.log('权属数据加载完成:', propertyData)
  } catch (error) {
    console.error('Excel处理失败:', error)
    updateStatus(
      'uploadStatus',
      `❌ 文件处理失败: ${error.message}`,
      'error',
    )
  }
}

// 生成模拟数据
function generateMockData() {
  if (spatialData.length === 0) {
    updateStatus('uploadStatus', '❌ 请先等待空间数据加载完成', 'error')
    return
  }

  updateStatus('uploadStatus', '🔄 正在生成模拟权属数据...', '')

  try {
    propertyData = excelProcessor.generateMockPropertyData()
    updateStatus(
      'uploadStatus',
      `✅ 成功生成${propertyData.length}条模拟权属数据`,
      'success',
    )

    // 启用融合按钮
    // document.getElementById('fusionBtn').disabled = false

    console.log('模拟权属数据生成完成:', propertyData)
  } catch (error) {
    console.error('模拟数据生成失败:', error)
    updateStatus(
      'uploadStatus',
      `❌ 模拟数据生成失败: ${error.message}`,
      'error',
    )
  }
}

// 执行数据融合
async function executeFusion() {
  if (spatialData.length === 0 || propertyData.length === 0) {
    alert('请确保空间数据和权属数据都已加载')
    return
  }

  updateStatus('uploadStatus', '🚀 正在执行数据融合算法...', '')

  // 禁用按钮防止重复点击
  // document.getElementById('fusionBtn').disabled = true

  try {
    // 模拟算法执行过程
    await new Promise((resolve) => setTimeout(resolve, 1000))

    // 获取房屋单元数据
    const unitsData = spatialData.filter((item) => item.type === 'unit')
    

    // 执行融合算法
    fusionResults = fusionEngine.fusionAlgorithm(unitsData, propertyData)
console.log(fusionResults, '融合结果数量:', fusionResults.length)
    // 更新统计信息
    updateFusionStats()

    updateStatus(
      'uploadStatus',
      `✅ 融合完成！成功匹配${fusionResults.length}条记录`,
      'success',
    )

    console.log('数据融合完成:', fusionResults)
  } catch (error) {
    console.error('融合算法执行失败:', error)
    updateStatus('uploadStatus', `❌ 融合失败: ${error.message}`, 'error')
  } finally {
    // 重新启用按钮
    // document.getElementById('fusionBtn').disabled = false
  }
}

// 更新融合统计信息
function updateFusionStats() {
  if (fusionResults.length === 0) return

  const stats = fusionEngine.getFusionStatistics()

  document.getElementById('matchedCount').textContent = stats.totalMatches
  document.getElementById('averageConfidence').textContent =
    (stats.averageConfidence * 100).toFixed(1) + '%'

  // 显示统计区域
  document.getElementById('statsGroup').style.display = 'block'
}

// 显示融合参数设置
function showFusionSettings() {
  const config = fusionEngine.config

  layer.open({
    area: ['500px', '400px'],
    title: '融合算法参数设置',
    content: `
                  <div style="padding: 20px;">
                      <div style="margin-bottom: 15px;">
                          <label>精确匹配权重: <span id="exactWeight">${config.exactMatchWeight}</span></label>
                          <input type="range" min="0" max="1" step="0.1" value="${config.exactMatchWeight}" 
                                 oninput="updateWeight('exact', this.value)" style="width: 100%; margin-top: 5px;">
                      </div>
                      <div style="margin-bottom: 15px;">
                          <label>空间匹配权重: <span id="spatialWeight">${config.spatialWeight}</span></label>
                          <input type="range" min="0" max="1" step="0.1" value="${config.spatialWeight}" 
                                 oninput="updateWeight('spatial', this.value)" style="width: 100%; margin-top: 5px;">
                      </div>
                      <div style="margin-bottom: 15px;">
                          <label>语义匹配权重: <span id="semanticWeight">${config.semanticWeight}</span></label>
                          <input type="range" min="0" max="1" step="0.1" value="${config.semanticWeight}" 
                                 oninput="updateWeight('semantic', this.value)" style="width: 100%; margin-top: 5px;">
                      </div>
                      <div style="margin-bottom: 15px;">
                          <label>融合阈值: <span id="thresholdValue">${config.threshold}</span></label>
                          <input type="range" min="0.1" max="1" step="0.05" value="${config.threshold}" 
                                 oninput="updateWeight('threshold', this.value)" style="width: 100%; margin-top: 5px;">
                      </div>
                      <p style="color: #666; font-size: 12px;">
                          调整这些参数可以影响数据融合的匹配策略和精度。修改后需要重新执行融合算法。
                      </p>
                  </div>
              `,
  })
}

// 更新权重参数
function updateWeight(type, value) {
  const config = fusionEngine.config
  console.log('config: ', config);

  switch (type) {
    case 'exact':
      config.exactMatchWeight = parseFloat(value)
      document.getElementById('exactWeight').textContent = value
      break
    case 'spatial':
      config.spatialWeight = parseFloat(value)
      document.getElementById('spatialWeight').textContent = value
      break
    case 'semantic':
      config.semanticWeight = parseFloat(value)
      document.getElementById('semanticWeight').textContent = value
      break
    case 'threshold':
      config.threshold = parseFloat(value)
      document.getElementById('thresholdValue').textContent = value
      break
  }
}

// 导出融合结果
function exportFusionResults() {
  if (fusionResults.length === 0) {
    alert('暂无融合结果可导出')
    return
  }

  const exportData = {
    timestamp: new Date().toISOString(),
    project: '安滨嘉苑不动产数据融合',
    statistics: fusionEngine.getFusionStatistics(),
    results: fusionResults,
  }

  const blob = new Blob([JSON.stringify(exportData, null, 2)], {
    type: 'application/json',
  })

  const url = URL.createObjectURL(blob)
  const a = document.createElement('a')
  a.href = url
  a.download = `fusion_results_${new Date()
    .toISOString()
    .slice(0, 10)}.json`
  document.body.appendChild(a)
  a.click()
  document.body.removeChild(a)
  URL.revokeObjectURL(url)

  updateStatus('uploadStatus', '✅ 融合结果已导出', 'success')
}

// 控制面板显示/隐藏
function toggleControlPanel() {
  const panel = document.getElementById('controlPanel')
  controlPanelVisible = !controlPanelVisible
  panel.style.display = controlPanelVisible ? 'block' : 'none'
}

// 更新状态信息
function updateStatus(elementId, message, type) {
  const element = document.getElementById(elementId)
  element.textContent = message

  // 移除之前的状态类
  element.classList.remove('status-success', 'status-error')

  // 添加新的状态类
  if (type === 'success') {
    element.classList.add('status-success')
  } else if (type === 'error') {
    element.classList.add('status-error')
  }
}

// 修改模型位置
function update3dtilesMaxtrix(tx, ty, rz, tz, rx, ry) {
  let params = {
    tx: tx, //模型中心X轴坐标（经度，单位：十进制度）
    ty: ty, //模型中心Y轴坐标（纬度，单位：十进制度）
    tz: tz ? tz : 0, //模型中心Z轴坐标（高程，单位：米）
    rx: rx ? rx : 0, //X轴（经度）方向旋转角度（单位：度）
    ry: ry ? ry : 0, //Y轴（纬度）方向旋转角度（单位：度）
    rz: rz ? rz : 0, //Z轴（高程）方向旋转角度（单位：度）
  }
  //旋转
  let mx = Cesium.Matrix3.fromRotationX(Cesium.Math.toRadians(params.rx))
  let my = Cesium.Matrix3.fromRotationY(Cesium.Math.toRadians(params.ry))
  let mz = Cesium.Matrix3.fromRotationZ(Cesium.Math.toRadians(params.rz))
  let rotationX = Cesium.Matrix4.fromRotationTranslation(mx)
  let rotationY = Cesium.Matrix4.fromRotationTranslation(my)
  let rotationZ = Cesium.Matrix4.fromRotationTranslation(mz)
  //平移
  let position = Cesium.Cartesian3.fromDegrees(
    params.tx,
    params.ty,
    params.tz,
  )
  let m = Cesium.Transforms.eastNorthUpToFixedFrame(position)

  let scale = Cesium.Matrix4.fromUniformScale(1)
  // //缩放
  Cesium.Matrix4.multiply(m, scale, m)
  //旋转、平移矩阵相乘
  Cesium.Matrix4.multiply(m, rotationX, m)
  Cesium.Matrix4.multiply(m, rotationY, m)
  Cesium.Matrix4.multiply(m, rotationZ, m)
  //赋值给tileset
  return m
}

this.tileset.readyPromise.then(function (tileset) {
  // tileset._root.transform = update3dtilesMaxtrix(117.0238, 32.5875, 0)
  // viewer.zoomTo(tileset)
})